//////////////////////////////////////
// Fast Container Library           //
// MIT License - Copyright (c) 2012 //
//////////////////////////////////////

#pragma once

#include "common.h"
#include "config.h"

FC_NAMESPACE_BEGIN


// allocator
class allocator;
//class zero_allocator;
class pool_allocator;
template <size_t N> class sso_allocator;

class fixed_allocator;
class fixed_node_allocator;

// misc. required
template <class T> struct less;


// string
template <class T> struct char_traits;
template <class T> class basic_string_ref;
template <class T, class Allocator = FC_DEFAULT_STRING_ALLOCATOR> class basic_string;
template <class T, size_t N = FC_DEFAULT_STRING_BUFFER_SIZE, class Allocator = FC_DEFAULT_FIXED_STRING_ALLOCATOR> class fixed_string;


typedef basic_string_ref<char> string_ref;
//typedef fixed_string<char> string;
typedef basic_string<char> string;

// static string
template <class T, size_t N> class static_basic_string;
template <size_t N> class static_string;



// vector types
template <class T, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_base;
template <class T, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector;
template <class T, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_ptr;
template <class T, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_pod;

template <class Key, class Compare = less<Key>, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_set;
template <class Key, class Compare = less<Key>, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_multiset;
template <class Key, class Value, class Compare = less<Key>, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_map;
template <class Key, class Value, class Compare = less<Key>, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class vector_multimap;
template <class T, class ParallelContainer = vector_set<size_t>, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class parallel;


// fixed vector types
template <class T, size_t N, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_vector;
template <class Key, size_t N, class Compare = less<Key>, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_vector_set;
template <class Key, size_t N, class Compare = less<Key>, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_vector_multiset;
template <class Key, class Value, size_t N, class Compare = less<Key>, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_vector_map;
template <class Key, class Value, size_t N, class Compare = less<Key>, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_vector_multimap;
template <class T, size_t N, class ParallelContainer = fixed_vector_set<size_t, N>, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_parallel;

// static vector types
template <class T, size_t N> class static_vector;


// dynamic array types
template <class T, class Allocator = FC_DEFAULT_ARRAY_ALLOCATOR> class array_base;
template <class T, class Allocator = FC_DEFAULT_ARRAY_ALLOCATOR> class dynamic_array;
template <class T, class Allocator = FC_DEFAULT_ARRAY_ALLOCATOR> class dynamic_array2d;
template <class T, class Allocator = FC_DEFAULT_ARRAY_ALLOCATOR> class dynamic_array3d;
template <class T, class Allocator = FC_DEFAULT_ARRAY_ALLOCATOR> class multi_array;


// static array types
template <class T, size_t N> struct static_array;
template <class T, size_t Y, size_t X> struct static_array2d;
template <class T, size_t Z, size_t Y, size_t X> struct static_array3d;


// bit container types
template <class Allocator = FC_DEFAULT_ARRAY_ALLOCATOR> class bit_array;
template <size_t N> class bitset;
template <size_t N> class static_bit_array;


// circular_buffer
template <class T, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class circular_buffer;
template <class T, size_t N, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_circular_buffer;

// deque
template <class T, class Allocator = FC_DEFAULT_VECTOR_ALLOCATOR> class deque;
template <class T, size_t N, class Allocator = FC_DEFAULT_FIXED_VECTOR_ALLOCATOR> class fixed_deque;

// list
template <class T, class Allocator = FC_DEFAULT_LIST_ALLOCATOR> class list;
template <class T, size_t N, class Allocator = FC_DEFAULT_FIXED_LIST_ALLOCATOR> class fixed_list;

// slist
template <class T, class Allocator = FC_DEFAULT_LIST_ALLOCATOR> class slist;
template <class T, size_t N, class Allocator = FC_DEFAULT_FIXED_LIST_ALLOCATOR> class fixed_slist;


// map, multimap, set, multiset
template <class Key, class Value, class Compare, class Allocator, bool MutableIterator> class rb_tree;
template <class Key, class Value, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_TREE_ALLOCATOR> class map;
template <class Key, class Value, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_TREE_ALLOCATOR> class multimap;
template <class Key, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_TREE_ALLOCATOR> class set;
template <class Key, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_TREE_ALLOCATOR> class multiset;


// fixed_map, fixed_multimap, fixed_set, fixed_multiset
template <class Key, class Value, size_t N, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_FIXED_TREE_ALLOCATOR> class fixed_map;
template <class Key, class Value, size_t N, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_FIXED_TREE_ALLOCATOR> class fixed_multimap;
template <class Key, size_t N, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_FIXED_TREE_ALLOCATOR> class fixed_set;
template <class Key, size_t N, class Compare = fc::less<Key>, class Allocator = FC_DEFAULT_FIXED_TREE_ALLOCATOR> class fixed_multiset;



// expansion containers
template < class T, class Container = vector<T> > class stack;
template < class T, class Container = deque<T> > class queue;
template < class T, class Compare = less<T>, class Container = vector<T> > class priority_queue;

template < class T, size_t N, class Container = fixed_vector<T, N> > class fixed_stack;
template < class T, size_t N, class Container = fixed_deque<T, N> > class fixed_queue;
template < class T, size_t N, class Compare = less<T>, class Container = fixed_vector<T, N> > class fixed_priority_queue;

template < class T, size_t N, class Container = static_vector<T, N> > class static_stack;
//template < class T, size_t N, class Container = static_deque<T, N> > class static_queue;
template < class T, size_t N, class Compare = less<T>, class Container = static_vector<T, N> > class static_priority_queue;


//class bit_array;
//template <size_t N> class static_bit_array;


FC_NAMESPACE_END
